/*
 * @(#)SearchableBar.java 10/11/2005
 *
 * Copyright 2002 - 2005 JIDE Software Inc. All rights reserved.
 */
package com.element.swing.search;

import com.element.plaf.UIDefaultsLookup;
import com.element.swing.Resource;
import com.element.ui.layout.JideBoxLayout;
import com.element.ui.popup.JidePopup;
import com.element.ui.popup.JidePopupFactory;
import com.element.util.CompareUtil;
import com.element.util.WrapperUtil;

import javax.swing.*;
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;
import javax.swing.event.PopupMenuEvent;
import javax.swing.event.PopupMenuListener;
import java.awt.*;
import java.awt.event.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Locale;

/**
 * <code>SearchableBar</code> is a convenient component to enable searching feature for components. As long as the
 * component support <code>Searchable</code> feature, it can work with <code>SearchableBar</code>.
 * <p/>
 * Different from <code>Searchable</code> feature which uses a small popup window to allow user typing in the searching
 * text, <code>SearchableBar</code> provides a full-size panel. Although they both pretty provide the same set of
 * features, they should be used in different cases to achieve the most desirable result.
 * <p/>
 * First of all, <code>SearchableBar</code> is a lot bigger than <code>Searchable</code>'s popup and need more space on
 * the screen. The component that installs <code>SearchableBar</code> should be large enough. In comparison,
 * <code>Searchable</code> can be installed on components of any size as it's a floating popup.
 * <p/>
 * Secondly, <code>SearchableBar</code> can be set visible all the time or can be set visible by a keystroke and stay
 * visible unless user explicitly hides it. If your user is not computer savvy, <code>SearchableBar</code> is more
 * appropriate because user can see searching feature very easily. <code>SearchableBar</code> can also be a better
 * replacement the traditional "Find" or "Search" dialog because <code>SearchableBar</code> doesn't block user input
 * like modal dialog. In comparison, <code>Searchable</code>'s popup is very transient. Mouse clicks outside the popup
 * will hide the popup. For computer savvy it is very helpful but it could be hard for non-computer savvy to
 * "understand" it. A good example is IntelliJ IDEA heavily uses Searchable popup because the users are all Java
 * developers. Firefox, on the other hand, uses SearchableBar because the users are just regular computer users.
 * <p/>
 * Although appearance wise, these two are very different, they both based on {@link Searchable} interface. So as
 * developer, both are almost the same. <code>SearchableBar</code> based on <code>Searchable</code>. So if you have an
 * interface of <code>Searchable</code>, all you need is to call
 * <code><pre>
 * SearchableBar.install(searchable, KeyStroke.getKeyStroke(KeyEvent.VK_F,
 * KeyEvent.CTRL_DOWN_MASK),
 * new SearchableBar.Installer() {
 *     public void openSearchBar(SearchableBar searchableBar) {
 *        // add code to show search bar
 *     }
 * <p/>
 *     public void closeSearchBar(SearchableBar searchableBar) {
 *        // add code to close search bar
 * }
 * });
 * </pre></code>
 * Or if you want fully control the SearchableBar, you can create one using one of its constructors and add to wherever
 * you want.
 * <p/>
 * There are a few options you can set on <code>SearchableBar</code>. You can set compact or full mode. Compact mode
 * will only use icon for buttons v.s. full mode will use both icon and text for buttons. All buttons on the
 * <code>SearchableBar</code> can be shown/hidden by using {@link #setVisibleButtons(int)} method. You can also set the
 * text field background for mismatch by using {@link #setMismatchForeground(Color)}.
 * <p/>
 */
public class SearchableBar extends JToolBar implements SearchableProvider {
	private final Searchable _searchable;

	protected JLabel _statusLabel;
	protected JLabel _leadingLabel;
	protected JTextField _textField;
	protected JComboBox<String> _comboBox;

	protected AbstractButton _closeButton;
	protected AbstractButton _findPrevButton;
	protected AbstractButton _findNextButton;
	protected AbstractButton _highlightsButton;

	protected AbstractButton _matchCaseCheckBox;
	protected AbstractButton _wholeWordsCheckBox;
	protected AbstractButton _repeatCheckBox;

	public static final int SHOW_CLOSE = 0x1;
	public static final int SHOW_NAVIGATION = 0x2;
	public static final int SHOW_HIGHLIGHTS = 0x4;
	public static final int SHOW_MATCHCASE = 0x8;
	public static final int SHOW_REPEATS = 0x10;
	public static final int SHOW_STATUS = 0x20;
	public static final int SHOW_WHOLE_WORDS = 0x40;
	public static final int SHOW_ALL = 0xFFFFFFFF;

	public static final String PROPERTY_MAX_HISTORY_LENGTH = "maxHistoryLength";

	private int _visibleButtons = ~SHOW_REPEATS; // default is show all but repeats
	private boolean _compact;
	private boolean _showMatchCount = false;

	private JidePopup _messagePopup;
	private MouseMotionListener _mouseMotionListener;
	private KeyListener _keyListener;
	private List<String> _searchHistory;
	private int _maxHistoryLength = 0;

	/**
	 * Creates a searchable bar.
	 *
	 * @param searchable the searchable
	 */
	public SearchableBar(Searchable searchable) {
		this(searchable, "", false);
	}

	/**
	 * Creates a searchable bar in compact mode or full mode.
	 *
	 * @param searchable the searchable
	 * @param compact    the flag indicating compact mode or full mode
	 */
	public SearchableBar(Searchable searchable, boolean compact) {
		this(searchable, "", compact);
	}

	/**
	 * Creates a searchable bar with initial searching text and in compact mode or full mode.
	 *
	 * @param searchable  the searchable
	 * @param initialText the initial text
	 * @param compact     the flag indicating compact mode or full mode
	 */
	public SearchableBar(Searchable searchable, String initialText, boolean compact) {
		setFloatable(false);
		setRollover(true);
		_searchable = searchable;
		_searchable.addSearchableListener(e -> {
			if (e.getID() == SearchableEvent.SEARCHABLE_MODEL_CHANGE && _searchable.getSearchingText() != null && _searchable.getSearchingText().length() != 0) {
				highlightAllOrNext();
			}
		});
		_searchable.setSearchableProvider(this);
		_compact = compact;
		initComponents(initialText);
	}

	private void initComponents(String initialText) {
		final AbstractAction closeAction = new AbstractAction() {
			public void actionPerformed(ActionEvent e) {
				if (getInstaller() != null) {
					getInstaller().closeSearchBar(SearchableBar.this);
				}
			}
		};

		final AbstractAction findNextAction = new AbstractAction() {
			public void actionPerformed(ActionEvent e) {
				_highlightsButton.setSelected(false);
				String text = getSearchingText();
				addSearchingTextToHistory(text);
				int cursor = _searchable.getSelectedIndex();
				_searchable.setCursor(cursor);
				int found = _searchable.findNext(text);
				if (found == cursor) {
					select(found, text, false);
					clearStatus();
				} else if (found != -1 && _searchable.isRepeats() && found <= cursor) {
					select(found, text, false);
					setStatus(getResourceString("SearchableBar.reachedBottomRepeat"), getImageIcon(SearchableBarIconsFactory.Buttons.REPEAT));
				} else if (!_searchable.isRepeats() && found == -1) {
					setStatus(getResourceString("SearchableBar.reachedBottom"), getImageIcon(SearchableBarIconsFactory.Buttons.ERROR));
				} else if (found != -1) {
					select(found, text, false);
					clearStatus();
					if (_searchable.getSearchingDelay() < 0) { // never updated the count so we update here
						highlightAllOrNext();
					}
				}
			}
		};

		final AbstractAction findPrevAction = new AbstractAction() {
			public void actionPerformed(ActionEvent e) {
				_highlightsButton.setSelected(false);
				String text = getSearchingText();
				addSearchingTextToHistory(text);
				int cursor = _searchable.getSelectedIndex();
				_searchable.setCursor(cursor);
				int found = _searchable.findPrevious(text);
				if (found == cursor) {
					select(found, text, false);
					clearStatus();
				} else if (found != -1 && _searchable.isRepeats() && found >= cursor) {
					select(found, text, false);
					setStatus(getResourceString("SearchableBar.reachedTopRepeat"), getImageIcon(SearchableBarIconsFactory.Buttons.REPEAT));
				} else if (!_searchable.isRepeats() && found == -1) {
					setStatus(getResourceString("SearchableBar.reachedTop"), getImageIcon(SearchableBarIconsFactory.Buttons.ERROR));
				} else if (found != -1) {
					select(found, text, false);
					clearStatus();
				}
			}
		};

		_mouseMotionListener = new MouseMotionListener() {
			public void mouseMoved(MouseEvent e) {
				hideMessage();
			}

			public void mouseDragged(MouseEvent e) {

			}
		};
		_keyListener = new KeyListener() {
			public void keyTyped(KeyEvent e) {
				hideMessage();
			}

			public void keyPressed(KeyEvent e) {

			}

			public void keyReleased(KeyEvent e) {

			}
		};

		_closeButton = createCloseButton(closeAction);
		_findNextButton = createFindNextButton(findNextAction);
		_findPrevButton = createFindPrevButton(findPrevAction);
		_highlightsButton = createHighlightButton();
		_matchCaseCheckBox = createMatchCaseButton();
		_wholeWordsCheckBox = createWholeWordsButton();
		_repeatCheckBox = createRepeatsButton();

		_statusLabel = new JLabel();

		//setup text field
		_textField = createTextField();
		_textField.addFocusListener(new FocusAdapter() {
			@Override
			public void focusGained(FocusEvent e) {
				_textField.selectAll();
			}
		});
		_textField.setColumns(13);
		DocumentListener listener = new DocumentListener() {
			private final Timer timer = new Timer(_searchable.getSearchingDelay(), e -> highlightAllOrNext());

			public void insertUpdate(DocumentEvent e) {
				startTimer();
			}

			public void removeUpdate(DocumentEvent e) {
				startTimer();
			}

			public void changedUpdate(DocumentEvent e) {
				startTimer();
			}

			void startTimer() {
				if (_searchable.getSearchingDelay() > 0) {
					if (timer.isRunning()) {
						timer.restart();
					} else {
						timer.setRepeats(false);
						timer.start();
					}
				} else if (_searchable.getSearchingDelay() == 0) {
					highlightAllOrNext();
				}
			}
		};
		_textField.getDocument().addDocumentListener(listener);
		_textField.setText(initialText);

		_textField.registerKeyboardAction(findNextAction, KeyStroke.getKeyStroke(KeyEvent.VK_DOWN, 0), JComponent.WHEN_FOCUSED);
		_textField.registerKeyboardAction(findNextAction, KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0), JComponent.WHEN_FOCUSED);
		_textField.registerKeyboardAction(findPrevAction, KeyStroke.getKeyStroke(KeyEvent.VK_UP, 0), JComponent.WHEN_FOCUSED);
		_textField.registerKeyboardAction(closeAction, KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0), JComponent.WHEN_FOCUSED);

		_comboBox = createComboBox();
		if (_comboBox.getEditor().getEditorComponent() instanceof JTextField) {
			((JTextField) _comboBox.getEditor().getEditorComponent()).getDocument().addDocumentListener(listener);
			registerKeyboardActions(closeAction, findNextAction, findPrevAction);
			_comboBox.addPopupMenuListener(new PopupMenuListener() {
				@Override
				public void popupMenuWillBecomeVisible(PopupMenuEvent e) {
					unregisterKeyboardActions();
				}

				@Override
				public void popupMenuWillBecomeInvisible(PopupMenuEvent e) {
					registerKeyboardActions(closeAction, findNextAction, findPrevAction);
				}

				@Override
				public void popupMenuCanceled(PopupMenuEvent e) {
					registerKeyboardActions(closeAction, findNextAction, findPrevAction);
				}
			});
		}
		_comboBox.setSelectedItem(initialText);
		_comboBox.setPreferredSize(_textField.getPreferredSize());

		installComponents();

		int found = _searchable.findFromCursor(getSearchingText());
		if (initialText.length() != 0 && found == -1) {
			select(found, initialText, false);
		}
	}

	private void registerKeyboardActions(AbstractAction closeAction, AbstractAction findNextAction, AbstractAction findPrevAction) {
		((JTextField) _comboBox.getEditor().getEditorComponent()).registerKeyboardAction(findNextAction, KeyStroke.getKeyStroke(KeyEvent.VK_DOWN, 0), JComponent.WHEN_FOCUSED);
		((JTextField) _comboBox.getEditor().getEditorComponent()).registerKeyboardAction(findNextAction, KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0), JComponent.WHEN_FOCUSED);
		((JTextField) _comboBox.getEditor().getEditorComponent()).registerKeyboardAction(findPrevAction, KeyStroke.getKeyStroke(KeyEvent.VK_UP, 0), JComponent.WHEN_FOCUSED);
		((JTextField) _comboBox.getEditor().getEditorComponent()).registerKeyboardAction(closeAction, KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0), JComponent.WHEN_FOCUSED);
	}

	private void unregisterKeyboardActions() {
		((JTextField) _comboBox.getEditor().getEditorComponent()).unregisterKeyboardAction(KeyStroke.getKeyStroke(KeyEvent.VK_DOWN, 0));
		((JTextField) _comboBox.getEditor().getEditorComponent()).unregisterKeyboardAction(KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0));
		((JTextField) _comboBox.getEditor().getEditorComponent()).unregisterKeyboardAction(KeyStroke.getKeyStroke(KeyEvent.VK_UP, 0));
		((JTextField) _comboBox.getEditor().getEditorComponent()).unregisterKeyboardAction(KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0));
	}

	/**
	 * Creates the text field where user types the text to be searched.
	 *
	 * @return a text field.
	 */
	protected JTextField createTextField() {
		return new JTextField();
	}

	/**
	 * Creates the combo box where user types the text to be searched.
	 *
	 * @return a combo box.
	 * @since 3.4.1
	 */
	protected JComboBox<String> createComboBox() {
		JComboBox<String> comboBox = new JComboBox<>();
		comboBox.setEditable(true);
		return comboBox;
	}

	/**
	 * Gets the underlying Searchable object.
	 *
	 * @return the Searchable object.
	 */
	public Searchable getSearchable() {
		return _searchable;
	}

	/**
	 * Creates the close button. Subclass can override it to create your own close button.
	 *
	 * @param closeAction the close action
	 * @return the close button.
	 */
	protected AbstractButton createCloseButton(AbstractAction closeAction) {
		AbstractButton button = new JButton(getImageIcon(SearchableBarIconsFactory.Buttons.CLOSE));
		button.addActionListener(closeAction);
		button.setRolloverEnabled(true);
		button.setBorder(BorderFactory.createEmptyBorder());
		button.setOpaque(false);
		button.setRequestFocusEnabled(false);
		button.setFocusable(false);
		button.setRolloverIcon(getImageIcon(SearchableBarIconsFactory.Buttons.CLOSE_ROLLOVER));
		return button;
	}

	/**
	 * Creates the find next button. Subclass can override it to create your own find next button.
	 *
	 * @param findNextAction the find next action
	 * @return the find next button.
	 */
	protected AbstractButton createFindNextButton(AbstractAction findNextAction) {
		AbstractButton button = new JButton(_compact ? "" : getResourceString("SearchableBar.findNext"),
				getImageIcon(SearchableBarIconsFactory.Buttons.NEXT));
		button.setToolTipText(getResourceString("SearchableBar.findNext.tooltip"));
		button.setMnemonic(getResourceString("SearchableBar.findNext.mnemonic").charAt(0));
		button.setRolloverIcon(getImageIcon(SearchableBarIconsFactory.Buttons.NEXT_ROLLOVER));
		button.setDisabledIcon(getImageIcon(SearchableBarIconsFactory.Buttons.NEXT_DISABLED));
		button.setRequestFocusEnabled(false);
		button.setFocusable(false);
		button.addActionListener(findNextAction);
		button.setEnabled(false);
		return button;
	}

	/**
	 * Creates the find prev button. Subclass can override it to create your own find prev button.
	 *
	 * @param findPrevAction the find previous action
	 * @return the find prev button.
	 */
	protected AbstractButton createFindPrevButton(AbstractAction findPrevAction) {
		AbstractButton button = new JButton(_compact ? "" : getResourceString("SearchableBar.findPrevious"),
				getImageIcon(SearchableBarIconsFactory.Buttons.PREVIOUS));
		button.setToolTipText(getResourceString("SearchableBar.findPrevious.tooltip"));
		button.setMnemonic(getResourceString("SearchableBar.findPrevious.mnemonic").charAt(0));
		button.setRolloverIcon(getImageIcon(SearchableBarIconsFactory.Buttons.PREVIOUS_ROLLOVER));
		button.setDisabledIcon(getImageIcon(SearchableBarIconsFactory.Buttons.PREVIOUS_DISABLED));
		button.setRequestFocusEnabled(false);
		button.setFocusable(false);
		button.addActionListener(findPrevAction);
		button.setEnabled(false);
		return button;
	}

	/**
	 * Creates the highlight button.
	 *
	 * @return the highlight button.
	 */
	protected AbstractButton createHighlightButton() {
		AbstractButton button = new JToggleButton(_compact ? "" : getResourceString("SearchableBar.highlights"),
				getImageIcon(SearchableBarIconsFactory.Buttons.HIGHLIGHTS));
		button.setToolTipText(getResourceString("SearchableBar.highlights.tooltip"));
		button.setMnemonic(getResourceString("SearchableBar.highlights.mnemonic").charAt(0));
		button.setSelectedIcon(getImageIcon(SearchableBarIconsFactory.Buttons.HIGHLIGHTS_SELECTED));
		button.setDisabledIcon(getImageIcon(SearchableBarIconsFactory.Buttons.HIGHLIGHTS_DISABLED));
		button.setRolloverIcon(getImageIcon(SearchableBarIconsFactory.Buttons.HIGHLIGHTS_ROLLOVER));
		button.setRolloverSelectedIcon(getImageIcon(SearchableBarIconsFactory.Buttons.HIGHLIGHTS_ROLLOVER_SELECTED));
		button.setRequestFocusEnabled(false);
		button.setFocusable(false);

		AbstractAction highlightAllAction = new AbstractAction() {
			public void actionPerformed(ActionEvent e) {
				addSearchingTextToHistory(getSearchingText());
				highlightAllOrNext();
			}
		};

		button.addActionListener(highlightAllAction);
		button.setEnabled(false);
		return button;
	}

	/**
	 * Creates the repeat button. By default it will return a JCheckBox. Subclass class can override it to return your
	 * own button or customize the button created by default as long as it can set underlying Searchable's repeats
	 * property.
	 *
	 * @return the repeat button.
	 */
	protected AbstractButton createRepeatsButton() {
		AbstractButton button = new JCheckBox(getResourceString("SearchableBar.repeats"));
		button.setMnemonic(getResourceString("SearchableBar.repeats.mnemonic").charAt(0));
		button.setRequestFocusEnabled(false);
		button.setFocusable(false);
		button.setSelected(getSearchable().isRepeats());
		button.addItemListener(e -> {
			if (e.getSource() instanceof AbstractButton) {
				getSearchable().setRepeats(((AbstractButton) e.getSource()).isSelected());
			}
		});
		button.setOpaque(false);
		return button;
	}

	/**
	 * Creates the match case button. By default it will return a JCheckBox. Subclass class can override it to return
	 * your own button or customize the button created by default as long as it can set underlying Searchable's
	 * caseSensitive property.
	 *
	 * @return the match case button.
	 */
	protected AbstractButton createMatchCaseButton() {
		JCheckBox checkBox = new JCheckBox(getResourceString("SearchableBar.matchCase"));
		checkBox.setMnemonic(getResourceString("SearchableBar.matchCase.mnemonic").charAt(0));
		checkBox.setRequestFocusEnabled(false);
		checkBox.setFocusable(false);
		checkBox.setSelected(getSearchable().isCaseSensitive());
		checkBox.addItemListener(e -> {
			if (e.getSource() instanceof AbstractButton) {
				getSearchable().setCaseSensitive(((AbstractButton) e.getSource()).isSelected());
				addSearchingTextToHistory(getSearchingText());
				highlightAllOrNext();
			}
		});
		checkBox.setOpaque(false);
		return checkBox;
	}

	/**
	 * Creates the whole words button. By default it will return a JCheckBox. Subclass class can override it to return
	 * your own button or customize the button created by default as long as it can set underlying Searchable's
	 * toEnd property.
	 *
	 * @return the whole words button.
	 * @since 3.5.2
	 */
	protected AbstractButton createWholeWordsButton() {
		JCheckBox checkBox = new JCheckBox(getResourceString("SearchableBar.wholeWords"));
		checkBox.setMnemonic(getResourceString("SearchableBar.wholeWords.mnemonic").charAt(0));
		checkBox.setRequestFocusEnabled(false);
		checkBox.setFocusable(false);
		checkBox.setSelected(false);
		checkBox.setEnabled(false);
		checkBox.setOpaque(false);
		return checkBox;
	}

	/**
	 * Adds the buttons to the SearchableBar. Subclass can override this method to rearrange the layout of those
	 * buttons.
	 */
	protected void installComponents() {
		setBorder(BorderFactory.createEtchedBorder());
		setLayout(new JideBoxLayout(this, JideBoxLayout.X_AXIS));
		add(Box.createHorizontalStrut(4), JideBoxLayout.FIX);
		if ((_visibleButtons & SHOW_CLOSE) != 0) {
			add(_closeButton);
			add(Box.createHorizontalStrut(10));
		}
		// setup the label
		_leadingLabel = new JLabel(getResourceString("SearchableBar.find"));
		_leadingLabel.setDisplayedMnemonic(getResourceString("SearchableBar.find.mnemonic").charAt(0));
		add(_leadingLabel);
		add(Box.createHorizontalStrut(2), JideBoxLayout.FIX);
		add(WrapperUtil.createCenterPanel(_textField), JideBoxLayout.FIX);
		add(WrapperUtil.createCenterPanel(_comboBox), JideBoxLayout.FIX);
		if (getMaxHistoryLength() == 0) {
			_leadingLabel.setLabelFor(_textField);
			_textField.setVisible(true);
			_comboBox.setVisible(false);
		} else {
			_leadingLabel.setLabelFor(_comboBox);
			_comboBox.setVisible(true);
			_textField.setVisible(false);
		}
		add(Box.createHorizontalStrut(2), JideBoxLayout.FIX);
		if ((_visibleButtons & SHOW_NAVIGATION) != 0) {
			add(_findNextButton);
			add(_findPrevButton);
		}
		if ((_visibleButtons & SHOW_HIGHLIGHTS) != 0) {
			add(_highlightsButton);
		}
		if ((_visibleButtons & SHOW_MATCHCASE) != 0) {
			add(_matchCaseCheckBox);
			add(Box.createHorizontalStrut(2));
		}
		if ((_visibleButtons & SHOW_REPEATS) != 0) {
			add(_repeatCheckBox);
			add(Box.createHorizontalStrut(2));
		}
		if ((_visibleButtons & SHOW_STATUS) != 0) {
			add(Box.createHorizontalStrut(24));
			add(_statusLabel, JideBoxLayout.VARY);
		}
		add(Box.createHorizontalStrut(6), JideBoxLayout.FIX);
	}

	/**
	 * Get if the SearchableBar is highlighting all matches.
	 * <p/>
	 * Even you set it to true, after the customer press previous or next button, this flag will be cleared.
	 *
	 * @return true if all matches are highlighted. Otherwise, false.
	 */
	public boolean isHighlightAll() {
		return _highlightsButton.isSelected();
	}

	/**
	 * Set if the SearchableBar will highlight all matches.
	 *
	 * @param highlightAll the flag
	 * @see #isHighlightAll()
	 */
	public void setHighlightAll(boolean highlightAll) {
		_highlightsButton.setSelected(highlightAll);
	}

	private int _previousCursor = -1;

	private void highlightAllOrNext() {
		if (_highlightsButton.isSelected()) {
			_previousCursor = _searchable.getCurrentIndex();
			highlightNext();
			highlightAll();
		} else {
			if (_previousCursor >= 0) {
				_searchable.setCursor(_previousCursor);
				_searchable.setSelectedIndex(_previousCursor, false);
			}
			highlightNext();
		}
	}

	private void highlightAll() {
		String text = getSearchingText();
		if (text == null || text.length() == 0) {
			_findNextButton.setEnabled(false);
			_findPrevButton.setEnabled(false);
			_highlightsButton.setEnabled(false);
			select(-1, "", false);
			clearStatus();
			return;
		}
		boolean old = _searchable.isRepeats();
		_searchable.setRepeats(false);
		int index = _searchable.findFirst(text);
		if (index != -1) {
			_searchable.setSelectedIndex(index, false); // clear side effect of ctrl-a will select all items
			_searchable.setCursor(index); // as setSelectedIndex is used directly, we have to manually set the cursor value.
			_findNextButton.setEnabled(true);
			_findPrevButton.setEnabled(true);
			_highlightsButton.setEnabled(true);
			clearStatus();
		} else {
			select(-1, text, false);
			_findNextButton.setEnabled(false);
			_findPrevButton.setEnabled(false);
			_highlightsButton.setEnabled(false);
			setStatus(getResourceString("SearchableBar.notFound"), getImageIcon(SearchableBarIconsFactory.Buttons.ERROR));
		}

		_searchable.highlightAll();
		_searchable.setRepeats(old);
		_searchable.setCursor(0);
	}

	private void highlightNext() {
		_searchable.cancelHighlightAll();
		String text = getSearchingText();
		if (text == null || text.length() == 0) {
			_findNextButton.setEnabled(false);
			_findPrevButton.setEnabled(false);
			_highlightsButton.setEnabled(false);
			select(-1, "", false);
			clearStatus();
			return;
		}
		int found = _searchable.findFromCursor(text);
		if (found == -1) {
			select(-1, "", false);
			_findNextButton.setEnabled(false);
			_findPrevButton.setEnabled(false);
			_highlightsButton.setEnabled(false);
			setStatus(getResourceString("SearchableBar.notFound"), getImageIcon(SearchableBarIconsFactory.Buttons.ERROR));
		} else {
			select(found, text, false);
			_findNextButton.setEnabled(true);
			_findPrevButton.setEnabled(true);
			_highlightsButton.setEnabled(true);
			clearStatus();
		}
	}

	private void clearStatus() {
		_statusLabel.setIcon(null);
		_textField.setBackground(UIDefaultsLookup.getColor("TextField.background"));
		_comboBox.getEditor().getEditorComponent().setBackground(UIDefaultsLookup.getColor("TextField.background"));
		if (isShowMatchCount() && (_textField.getText().length() > 0 || (_comboBox.isVisible() && _comboBox.getEditor().getEditorComponent() instanceof JTextField && ((JTextField) _comboBox.getEditor().getEditorComponent()).getText().length() > 0))) {
			_statusLabel.setText(getSearchable().getMatchCount() + " " + getResourceString("SearchableBar.matches"));
		} else {
			_statusLabel.setText("");
		}
		hideMessage();
	}

	private void setStatus(String message, Icon icon) {
		_statusLabel.setIcon(icon);
		_statusLabel.setText(message);
		_statusLabel.setToolTipText(message);
		if (!_statusLabel.isShowing() || _statusLabel.getWidth() < 25) {
			showMessage(message);
		}
	}

	/**
	 * Makes the search field having focus.
	 */
	public void focusSearchField() {
		if (_textField != null && _textField.isVisible()) {
			_textField.requestFocus();
		}
		if (_comboBox != null && _comboBox.isVisible()) {
			_comboBox.requestFocus();
		}
	}

	protected void select(int index, String searchingText, boolean incremental) {
		if (index != -1) {
			_searchable.setSelectedIndex(index, incremental);
			_searchable.setCursor(index, incremental);
			_textField.setBackground(UIDefaultsLookup.getColor("TextField.background"));
			_comboBox.getEditor().getEditorComponent().setBackground(UIDefaultsLookup.getColor("TextField.background"));
		} else {
			_searchable.setSelectedIndex(-1, false);
			_textField.setBackground(getMismatchBackground());
			_comboBox.getEditor().getEditorComponent().setBackground(UIDefaultsLookup.getColor("TextField.background"));
		}
		_searchable.firePropertyChangeEvent(searchingText);
		if (index != -1) {
			Object element = _searchable.getElementAt(index);
			_searchable.fireSearchableEvent(new SearchableEvent(_searchable, SearchableEvent.SEARCHABLE_MATCH, searchingText, element, _searchable.convertElementToString(element)));
		} else {
			_searchable.fireSearchableEvent(new SearchableEvent(_searchable, SearchableEvent.SEARCHABLE_NOMATCH, searchingText));
		}
	}

	/**
	 * Gets the searching text.
	 *
	 * @return the searching text.
	 */
	public String getSearchingText() {
		if (_textField != null && _textField.isVisible()) {
			return _textField.getText();
		}
		if (_comboBox != null && _comboBox.isVisible()) {
			Object item = _comboBox.getEditor().getItem();
			return item == null ? "" : item.toString();
		}
		return "";
	}

	/**
	 * Sets the searching text.
	 *
	 * @param searchingText the new searching text.
	 */
	public void setSearchingText(String searchingText) {
		if (_textField != null && _textField.isVisible()) {
			_textField.setText(searchingText);
		}
		if (_comboBox != null && _comboBox.isVisible()) {
			_comboBox.setSelectedItem(searchingText);
		}
	}

	/**
	 * Returns false.
	 *
	 * @return false.
	 */
	public boolean isPassive() {
		return false;
	}

	final private static Color DEFAULT_MISMATCH_BACKGROUND = new Color(255, 85, 85);
	private Color _mismatchBackground;

	/**
	 * Sets the background for mismatch.
	 *
	 * @param mismatchBackground the mismatch background
	 */
	public void setMismatchForeground(Color mismatchBackground) {
		_mismatchBackground = mismatchBackground;
	}

	/**
	 * Gets the background color when the searching text doesn't match with any of the elements in the component.
	 *
	 * @return the foreground color for mismatch. If you never call {@link #setMismatchForeground(Color)}. red
	 * color will be used.
	 */
	public Color getMismatchBackground() {
		if (_mismatchBackground == null) {
			return DEFAULT_MISMATCH_BACKGROUND;
		} else {
			return _mismatchBackground;
		}
	}

	private Installer _installer;

	/**
	 * Gets the search history.
	 *
	 * @return the search history.
	 * @since 3.4.1
	 */
	public String[] getSearchHistory() {
		return _searchHistory == null ? new String[0] : _searchHistory.toArray(new String[0]);
	}

	/**
	 * Sets the search history.
	 *
	 * @param searchHistory the search history
	 * @since 3.4.1
	 */
	public void setSearchHistory(String[] searchHistory) {
		if (searchHistory == null || searchHistory.length == 0) {
			_searchHistory = null;
		} else {
			_searchHistory = new ArrayList<>();
			_searchHistory.addAll(Arrays.asList(searchHistory));
		}
		DefaultComboBoxModel<String> model = new DefaultComboBoxModel<>();
		if (_searchHistory != null) {
			for (int i = _searchHistory.size() - 1; i >= 0; i--) {
				model.addElement(_searchHistory.get(i));
			}
		}
		model.insertElementAt("", 0);
		_comboBox.setModel(model);
		_comboBox.setSelectedIndex(0);
	}

	/**
	 * Gets the maximum search history length.
	 *
	 * @return the maximum search history length.
	 * @see #setMaxHistoryLength(int)
	 * @since 3.4.1
	 */
	public int getMaxHistoryLength() {
		return _maxHistoryLength;
	}

	/**
	 * Sets the maximum search history length.
	 * <p/>
	 * By default, it's 0, which means there is no history to shown to keep the behavior backward compatibility. To show
	 * history with a JComboBox, please use this method to set a positive or negative value. Any negative value means
	 * that the history size is unlimited.
	 *
	 * @param maxHistoryLength the maximum history length
	 * @since 3.4.1
	 */
	public void setMaxHistoryLength(int maxHistoryLength) {
		if (_maxHistoryLength != maxHistoryLength) {
			int old = _maxHistoryLength;
			_maxHistoryLength = maxHistoryLength;
			if (getMaxHistoryLength() == 0) {
				_leadingLabel.setLabelFor(_textField);
				_textField.setVisible(true);
				Object item = _comboBox.getEditor().getItem();
				_textField.setText(item == null ? "" : item.toString());
				_comboBox.setVisible(false);
			} else if (!_comboBox.isVisible()) {
				_leadingLabel.setLabelFor(_comboBox);
				_comboBox.setVisible(true);
				_comboBox.getEditor().setItem(_textField.getText());
				_textField.setVisible(false);
			}
			firePropertyChange(PROPERTY_MAX_HISTORY_LENGTH, old, _maxHistoryLength);
		}
	}

	/**
	 * Gets the flag indicating if the match count should be displayed in the status label.
	 *
	 * @return true if the match count should be displayed. Otherwise false.
	 * @see #setShowMatchCount(boolean)
	 * @since 3.5.2
	 */
	public boolean isShowMatchCount() {
		return _showMatchCount;
	}

	/**
	 * Sets the flag indicating if the match count should be displayed in the status label.
	 * <p/>
	 * By default, the flag is set to false to keep the original behavior.
	 *
	 * @param showMatchCount
	 * @since 3.5.2
	 */
	public void setShowMatchCount(boolean showMatchCount) {
		_showMatchCount = showMatchCount;
		if (getSearchable() != null) {
			getSearchable().setCountMatch(isShowMatchCount());
		}
	}

	/**
	 * The installer for SearchableBar.
	 */
	public interface Installer {
		/**
		 * Called to show the SearchableBar so that user can see it.
		 * <p/>
		 * For example, if you want to add a SearchableBar to the south of a JTextArea, you should add JTextArea to the
		 * CENTER of a BorderLayout panel. In this method, you add the SearchableBar to the SOUTH of the same
		 * BorderLayout panel.
		 *
		 * @param searchableBar the searchable bar
		 */
		void openSearchBar(SearchableBar searchableBar);

		/**
		 * Called to hide the SearchableBar.
		 *
		 * @param searchableBar the searchable bar
		 */
		void closeSearchBar(SearchableBar searchableBar);
	}

	public Installer getInstaller() {
		return _installer;
	}

	/**
	 * Sets the installer. Installer is responsible for the installation and uninstallation of SearchableBar.
	 *
	 * @param installer the installer
	 */
	public void setInstaller(Installer installer) {
		_installer = installer;
	}

	/**
	 * Installs a SearchableBar on a component. This is just a convenient method for you, you can install it in your own
	 * code. See below for the actual code we used in this method.
	 * <p/>
	 * <code><pre>
	 * final SearchableBar searchableBar = new SearchableBar(searchable);
	 * searchableBar.setInstaller(installer);
	 * ((JComponent) searchable.getComponent()).registerKeyboardAction(new AbstractAction() {
	 *     public void actionPerformed(ActionEvent e) {
	 *         searchableBar.getInstaller().openSearchBar(searchableBar);
	 *         searchableBar.focusSearchField();
	 *     }
	 * }, keyStroke, JComponent.WHEN_FOCUSED);
	 * return searchableBar;
	 * </pre></code>
	 *
	 * @param searchable the searchable
	 * @param keyStroke  the key stroke
	 * @param installer  the installer
	 * @return the SearchableBar that is created.
	 */
	public static SearchableBar install(Searchable searchable, KeyStroke keyStroke, Installer installer) {
		final SearchableBar searchableBar = new SearchableBar(searchable);
		searchableBar.setInstaller(installer);
		((JComponent) searchable.getComponent()).registerKeyboardAction(new AbstractAction() {
			public void actionPerformed(ActionEvent e) {
				searchableBar.getInstaller().openSearchBar(searchableBar);
				searchableBar.focusSearchField();
			}
		}, keyStroke, JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);
		return searchableBar;
	}

	@Override
	public void processKeyEvent(KeyEvent e) {
	}

	public int getVisibleButtons() {
		return _visibleButtons;
	}

	/**
	 * Sets visible buttons on <code>SearchableBar</code>.
	 *
	 * @param visibleButtons bit-wise all of several constants. Valid constants are <ul> <li> {@link #SHOW_CLOSE} - the
	 *                       close button <li> {@link #SHOW_NAVIGATION} - the find next and find previous buttons <li>
	 *                       {@link #SHOW_HIGHLIGHTS} - highlights all button <li> {@link #SHOW_MATCHCASE} - match case
	 *                       button <li> {@link #SHOW_WHOLE_WORDS} - word only button <li> {@link #SHOW_REPEATS} - repeats
	 *                       button <li> {@link #SHOW_STATUS} - status area <li> {@link #SHOW_ALL} - all buttons </ul>
	 *                       For example, if you want to show only close and highlights all button, call
	 *                       <code>setVisibleButtons(SearchableBar.SHOW_CLOSE | SearchableBar.SHOW_HIGHLIGHTS)</code>.
	 */
	public void setVisibleButtons(int visibleButtons) {
		_visibleButtons = visibleButtons;
		removeAll();
		installComponents();
		revalidate();
		repaint();
	}

	/**
	 * Checks if <code>SearchableBar</code> is in compact mode.
	 *
	 * @return true if in compact. Otherwise, false.
	 */
	public boolean isCompact() {
		return _compact;
	}

	/**
	 * Sets the <code>SearchableBar</code> to compact or full mode. In compact mode will only use icon for buttons v.s.
	 * full mode will use both icon and text for buttons.
	 *
	 * @param compact the flag
	 */
	public void setCompact(boolean compact) {
		_compact = compact;
		_findNextButton.setText(_compact ? "" : getResourceString("SearchableBar.findNext"));
		_highlightsButton.setText(_compact ? "" : getResourceString("SearchableBar.highlights"));
		_findPrevButton.setText(_compact ? "" : getResourceString("SearchableBar.findPrevious"));
	}

	/**
	 * Gets the icons from SearchableBarIconsFactory. Subclass can override this method if they want to provide their
	 * own icon.
	 *
	 * @param name the icon name
	 * @return the icon of the specified name.
	 */
	protected ImageIcon getImageIcon(String name) {
		return SearchableBarIconsFactory.getImageIcon(name);
	}

	/**
	 * Gets the localized string from resource bundle. Subclass can override it to provide its own string. Available
	 * keys are defined in swing.properties that begin with "SearchableBar.".
	 *
	 * @param key the resource key
	 * @return the localized string.
	 */
	protected String getResourceString(String key) {
		return Resource.getResourceBundle(Locale.getDefault()).getString(key);
	}

	private void showMessage(String message) {
		hideMessage();

		_messagePopup = JidePopupFactory.getSharedInstance().createPopup();
		JLabel label = new JLabel(message);
		label.setOpaque(true);
		label.setFont(UIDefaultsLookup.getFont("Label.font").deriveFont(Font.BOLD, 11));
		label.setBackground(new Color(253, 254, 226));
		label.setBorder(BorderFactory.createEmptyBorder(2, 6, 2, 6));
		label.setForeground(UIDefaultsLookup.getColor("ToolTip.foreground"));

		_messagePopup.getContentPane().setLayout(new BorderLayout());
		_messagePopup.getContentPane().add(label);
		if (_textField != null && _textField.isVisible()) {
			_messagePopup.setOwner(_textField);
		}
		if (_comboBox != null && _comboBox.isVisible()) {
			_messagePopup.setOwner(_comboBox);
		}

		_messagePopup.setDefaultMoveOperation(JidePopup.HIDE_ON_MOVED);
		_messagePopup.setTransient(true);
		_messagePopup.showPopup();

		addMouseMotionListener(_mouseMotionListener);
		if (_textField != null && _textField.isVisible()) {
			_textField.addKeyListener(_keyListener);
		}
		if (_comboBox != null && _comboBox.isVisible()) {
			_comboBox.addKeyListener(_keyListener);
		}
	}

	private void hideMessage() {
		if (_messagePopup != null) {
			_messagePopup.hidePopupImmediately();
			_messagePopup = null;
		}
		if (_mouseMotionListener != null) {
			removeMouseMotionListener(_mouseMotionListener);
		}
		if (_keyListener != null) {
			_textField.removeKeyListener(_keyListener);
			_comboBox.removeKeyListener(_keyListener);
		}
	}

	private void addSearchingTextToHistory(String searchingText) {
		if (searchingText == null || searchingText.length() == 0) {
			return;
		}
		if (_searchHistory == null) {
			_searchHistory = new ArrayList<>();
		}
		if (_searchHistory.size() == 0) {
			_searchHistory.add(searchingText);
			DefaultComboBoxModel<String> model = new DefaultComboBoxModel<>();
			model.addElement(searchingText);
			_comboBox.setModel(model);
			return;
		}
		if (CompareUtil.equals(_searchHistory.get(_searchHistory.size() - 1), searchingText)) {
			return;
		}
		_searchHistory.remove(searchingText); // remove existing entry first
		_searchHistory.add(searchingText);
		if (getMaxHistoryLength() > 0 && _searchHistory.size() > getMaxHistoryLength()) {
			_searchHistory.remove(0);
		}
		DefaultComboBoxModel<String> model = new DefaultComboBoxModel<>();
		for (int i = _searchHistory.size() - 1; i >= 0; i--) {
			model.addElement(_searchHistory.get(i));
		}
		_comboBox.setModel(model);
	}
}
